import math


def number_to_chinese(num):
    """
    将阿拉伯数字转换为中文大写数字（修正版）
    :param num: 数字，可以是整数或浮点数
    :return: 中文大写数字字符串
    """
    # 定义数字对应的大写
    digit_map = {
        '0': '零',
        '1': '壹',
        '2': '贰',
        '3': '叁',
        '4': '肆',
        '5': '伍',
        '6': '陆',
        '7': '柒',
        '8': '捌',
        '9': '玖'
    }
    
    # 定义单位
    unit_map = [
        ('', '拾', '佰', '仟'),       # 个位
        ('万', '拾万', '佰万', '仟万'), # 万位
        ('亿', '拾亿', '佰亿', '仟亿'), # 亿位
        ('兆', '拾兆', '佰兆', '仟兆')  # 兆位
    ]
    
    # 处理小数部分
    decimal_units = ['角', '分']
    
    # 将数字转换为字符串，处理正负
    if not isinstance(num, (int, float)):
        raise ValueError("输入必须是数字")
    
    is_negative = False
    if num < 0:
        is_negative = True
        num = abs(num)
    
    num_str = format(num, '.2f')  # 格式化为两位小数
    
    # 分离整数和小数部分
    integer_part, decimal_part = num_str.split('.')
    
    # 处理整数部分
    def convert_integer_part(integer_str):
        if integer_str == '0':
            return ['零']
        
        result = []
        length = len(integer_str)
        
        # 分组处理，每4位一组
        groups = []
        while integer_str:
            groups.append(integer_str[-4:])
            integer_str = integer_str[:-4]
        groups.reverse()
        
        for i, group in enumerate(groups):
            group = group.lstrip('0')
            if not group:  # 全零组
                # 检查是否需要添加"零"或单位
                if i < len(groups) - 1 and any(c != '0' for c in groups[i+1]):
                    result.append('零')
                continue
            
            level = len(groups) - i - 1
            for j, digit in enumerate(group):
                if digit == '0':
                    # 处理连续的零，只保留一个
                    if j < len(group) - 1 and group[j+1] != '0':
                        result.append('零')
                else:
                    result.append(digit_map[digit])
                    pos = len(group) - j - 1
                    if pos > 0:
                        result.append(unit_map[0][pos])
            
            # 添加级单位（万、亿、兆）
            if level > 0 and any(c != '0' for c in group):
                result.append(unit_map[level][0])
        
        return result
    
    integer_chinese = convert_integer_part(integer_part)
    
    # 处理小数部分
    decimal_chinese = []
    if decimal_part != '00':
        for i, digit in enumerate(decimal_part[:2]):  # 只处理两位小数
            if digit != '0':
                decimal_chinese.append(digit_map[digit])
                if i < len(decimal_units):
                    decimal_chinese.append(decimal_units[i])
    
    # 组合结果
    result = []
    if is_negative:
        result.append('(负数)')
    
    if integer_chinese:
        result.extend(integer_chinese)
        result.append('圆')
    
    if decimal_chinese:
        result.extend(decimal_chinese)
    else:
        if integer_chinese and integer_chinese != ['零']:
            result.append('整')
    
    # 特殊情况处理：零元
    if integer_chinese == ['零'] and not decimal_chinese:
        return '零元整'
    
    return ''.join(result)

        
def chinese_to_number(chinese_str):
    """
    将中文大写数字转换为阿拉伯数字
    :param chinese_str: 中文大写数字字符串
    :return: 阿拉伯数字（浮点数或整数）
    """
    # 定义中文数字到阿拉伯数字的映射
    digit_map = {
        '零': 0,
        '壹': 1,
        '贰': 2,
        '叁': 3,
        '肆': 4,
        '伍': 5,
        '陆': 6,
        '柒': 7,
        '捌': 8,
        '玖': 9
    }
    
    # 定义单位到乘数的映射
    unit_map = {
        '拾': 10,
        '佰': 100,
        '仟': 1000,
        '万': 10000,
        '亿': 100000000,
        '兆': 1000000000000,
        '角': 0.1,
        '分': 0.01
    }
    
    # 去除可能的中文符号
    chinese_str = chinese_str.replace('整', '').replace('圆', '元').strip()
    
    # 检查是否为负数
    is_negative = False
    if chinese_str.startswith('(负数)') or chinese_str.startswith('负'):
        is_negative = True
        chinese_str = chinese_str[3:] if chinese_str.startswith('(负数)') else chinese_str[1:]
    
    # 分离整数和小数部分
    if '元' in chinese_str:
        integer_part, decimal_part = chinese_str.split('元', 1)
    else:
        integer_part = ''
        decimal_part = chinese_str
    
    # 处理整数部分
    integer_value = 0
    current_value = 0
    temp_value = 0
    
    if integer_part:
        for char in integer_part:
            if char in digit_map:
                current_value = digit_map[char]
            elif char in unit_map:
                unit = unit_map[char]
                if unit >= 10:  # 是整数单位
                    if unit in (10000, 100000000, 1000000000000):  # 万、亿、兆单位
                        temp_value += current_value
                        integer_value += temp_value * unit
                        temp_value = 0
                        current_value = 0
                    else:  # 拾、佰、仟单位
                        temp_value += current_value * unit
                        current_value = 0
                else:  # 是小数单位（不应该出现在整数部分）
                    pass
        integer_value += temp_value + current_value
    
    # 处理小数部分
    decimal_value = 0.0
    current_value = 0
    
    for char in decimal_part:
        if char in digit_map:
            current_value = digit_map[char]
        elif char in unit_map:
            unit = unit_map[char]
            if unit < 1:  # 是小数单位
                decimal_value += current_value * unit
                current_value = 0
    
    # 合并结果
    result = integer_value + decimal_value
    
    if is_negative:
        result = -result
    
    # 如果是整数，返回整数类型
    if decimal_value == 0.0 and '.' not in str(result):
        return int(result)
    return result


def test_num2chinese():
    test_numbers = [
        0.00,0, 1, 10, 100, 1000, 10000, 100000, 1000000,
        123, 1234, 12345, 123456, 1234567, 12345678, 123456789,
        0.1, 0.01, 0.11, 1.1, 10.01, 100.1, 1000.01,
        -123, -123.45, 100000000, 2000000000, 30000000000,-1499250.0
    ]
    
    for num in test_numbers:
        print(f"{num}: {number_to_chinese(num)}")

# 测试示例
def test_chinese2num():
    test_cases = [
        "零元整",
        "壹圆整",
        "壹拾圆整",
        "壹佰圆整",
        "壹仟圆整",
        "壹万圆整",
        "壹拾万圆整",
        "壹佰万圆整",
        "壹佰贰拾叁圆整",
        "壹仟贰佰叁拾肆圆整",
        "壹万贰仟叁佰肆拾伍圆整",
        "壹拾贰万叁仟肆佰伍拾陆圆整",
        "壹佰贰拾叁万肆仟伍佰陆拾柒圆整",
        "壹仟贰佰叁拾肆万伍仟陆佰柒拾捌圆整",
        "壹亿贰仟叁佰肆拾伍万陆仟柒佰捌拾玖圆整",
        "零圆壹角",
        "零圆零壹分",
        "零圆壹角壹分",
        "壹圆壹角",
        "壹圆零壹分",
        "壹圆壹角壹分",
        "壹拾圆零壹分",
        "壹佰圆壹角",
        "壹仟圆零壹分",
        "(负数)壹仟贰佰叁拾肆圆伍角陆分",
        "负壹亿圆整"
    ]
    
    for case in test_cases:
        print(f"'{case}': {chinese_to_number(case)}")

def are_numbers_equal(a, b):
    """
    功能：两个数字的值是否相等，无论它们是整数还是浮点数；
    注意浮点数精度问题，比如0.1 + 0.2 == 0.3会返回False，这是浮点数计算的特性
    调用：
    num_convert=chinese_to_number("贰万壹仟圆整")
    print(are_numbers_equal(num_convert,21000.00))
    print(0.1 + 0.2 == 0.3)
    """
    try:
        a_float = float(a)
        b_float = float(b)
        return math.isclose(a_float, b_float)
    except (ValueError, TypeError):
        return False
          


